/*
 * @Author: 0x9DEFA478
 * @Date: 2021-03-11 17:53:34
 * @LastEditTime: 2021-06-05 16:49:08
 * @LastEditors: 0x9DEFA478
 * @Description: 先进先出控制器 仅需保障写入不被重入 读取不被重入 fifo就不会损坏 读取(写入)可被写入(读取)打断而FIFO不会损坏 具有长度记录 兼具效率与空间利用率
 * ============================================================================================================================================
 *                                                                                               ************      ****************************
 *                                                                                             ************      ****************************  
 *                                                                                           ************      ****************************    
 *                                                                                         ************      ****************************      
 *                                                                                       ************      ************                        
 *                                                                                     ************      ************                          
 *                                                                                   ************      ************                            
 *                                                                                 ************      ************                              
 *                                                                               ************      ************                                
 *                                                                             ************      ************                                  
 *                                                                           ************      ************                                    
 *                                                                         ************      ************                                      
 *                                                                       ************      ************                                        
 *                                                                     ************      ************                                          
 *                                                                   ************      ************                                            
 *                                                                 ************      ************                                              
 *                                                               ************      ************                                                
 *                                                             ************      ************                                                  
 *                                                           ************      ************                                                    
 *                                                         ************      ************                                                      
 *                                                       ************      ************                                                        
 *                                                     ************      ************                                                          
 *                                                   ************      ************                                                            
 *                                                 ************      ************                                                              
 *                                               ************      ************                                                                
 *                                             ************      ************                                                                  
 *                                           ************      ************                                                                    
 *                                         ************      ************                                                                      
 *                                       ************      ************                                                                        
 *                                     ************      ************                                                                          
 *                                   ************      ************                                                                            
 *                                 ************      ************                                                                              
 *                               ************      ************                                                                                
 *                             ************      ************                                                                                  
 *                           ************      ************                                                                                    
 *                         ************      ************                                                                                      
 *       ****************************      ************                                                                                        
 *     ****************************      ************                                                                                          
 *   ****************************      ************                                                                                            
 * ****************************      ************                                                                                              
 * ============================================================================================================================================
 * 
 */



#include "H_FIFO_Pack.h"


/**
 * @brief 向FIFO中添加包
 * @param fifo FIFO结构体
 * @param Data 要添加的数据
 * @param Len 长度
 * @return 0:成功 其他:失败 空间或剩余数量不足
 */
int H_FIFO_Pack_Byte_AddPack(H_FIFO_Pack_Byte_Def* fifo,Hbyte_ptr Data,int Len){

	int EmptySize;
	int EmptyNum;
	int SizeArray_InId;
	int SizeArray_OutId;
	int Buffer_InId;
	int Buffer_OutId;
	int SizeArraySize;
	int BufferSize;
	volatile Hbyte* dst_ucp;
	int i;

	SizeArray_InId=fifo->SizeArray_InId;
	SizeArray_OutId=fifo->SizeArray_OutId;
	SizeArraySize=fifo->SizeArraySize;
	//判断是否有足够容量
	if(SizeArray_InId < SizeArray_OutId){
		EmptyNum = SizeArray_OutId - SizeArray_InId;
	}else{
		EmptyNum = SizeArraySize - SizeArray_InId + SizeArray_OutId;
	}
	//至少要空出一个容量
	if(EmptyNum<2){
		return -1;
	}

	Buffer_InId=fifo->Buffer_InId;
	Buffer_OutId=fifo->Buffer_OutId;
	BufferSize=fifo->BufferSize;
	if(Buffer_InId < Buffer_OutId){
		EmptySize = Buffer_OutId - Buffer_InId;
	}else{
		EmptySize = BufferSize - Buffer_InId;
		if(EmptySize < Buffer_OutId){
			EmptySize = Buffer_OutId;
		}
	}
	//容量是否足够
	if(EmptySize<Len){

		return -2;
	}

	//如果到此处 说明肯定可写入 要不从0写入要不从fifo->Buffer_InId写入

	//装填数据
	//判断从0写入还是从fifo->Buffer_InId写入
	if((BufferSize - Buffer_InId)<Len){
		//从0写入
		dst_ucp=fifo->Buffer;

		i=Len;
		while(i>7){
			i-=8;

			dst_ucp[0]=Data[0];
			dst_ucp[1]=Data[1];
			dst_ucp[2]=Data[2];
			dst_ucp[3]=Data[3];
			dst_ucp[4]=Data[4];
			dst_ucp[5]=Data[5];
			dst_ucp[6]=Data[6];
			dst_ucp[7]=Data[7];

			dst_ucp=&dst_ucp[8];
			Data=&Data[8];
		}
		while(i>0){
			i--;

			dst_ucp[0]=Data[0];

			dst_ucp=&dst_ucp[1];
			Data=&Data[1];
		}
		
		Buffer_InId=Len;
	}else{
		//从fifo->Buffer_InId写入
		dst_ucp=fifo->Buffer;
		dst_ucp=&dst_ucp[Buffer_InId];

		i=Len;
		while(i>7){
			i-=8;

			dst_ucp[0]=Data[0];
			dst_ucp[1]=Data[1];
			dst_ucp[2]=Data[2];
			dst_ucp[3]=Data[3];
			dst_ucp[4]=Data[4];
			dst_ucp[5]=Data[5];
			dst_ucp[6]=Data[6];
			dst_ucp[7]=Data[7];

			dst_ucp=&dst_ucp[8];
			Data=&Data[8];
		}
		while(i>0){
			i--;

			dst_ucp[0]=Data[0];

			dst_ucp=&dst_ucp[1];
			Data=&Data[1];
		}

		if((Buffer_InId+Len)==BufferSize){
			fifo->Buffer_InId=0;
		}else{
			fifo->Buffer_InId=Buffer_InId+Len;
		}
	}

	fifo->SizeArray[SizeArray_InId]=Len;

	if(SizeArray_InId==(SizeArraySize-1)){
		fifo->SizeArray_InId=0;
	}else{
		fifo->SizeArray_InId=SizeArray_InId+1;
	}

	return 0;
}

/**
 * @brief 向FIFO中添加包
 * @param fifo FIFO结构体
 * @param Data 要添加的数据
 * @param Len 长度
 * @return 0:成功 其他:失败 空间或剩余数量不足
 */
int H_FIFO_Pack_UInt16_AddPack(H_FIFO_Pack_UInt16_Def* fifo,Huint16_ptr Data,int Len){

	int EmptySize;
	int EmptyNum;
	int SizeArray_InId;
	int SizeArray_OutId;
	int Buffer_InId;
	int Buffer_OutId;
	int SizeArraySize;
	int BufferSize;
	volatile Huint16* dst_ucp;
	int i;


	SizeArray_InId=fifo->SizeArray_InId;
	SizeArray_OutId=fifo->SizeArray_OutId;
	SizeArraySize=fifo->SizeArraySize;
	//判断是否有足够容量
	if(SizeArray_InId < SizeArray_OutId){
		EmptyNum = SizeArray_OutId - SizeArray_InId;
	}else{
		EmptyNum = SizeArraySize - SizeArray_InId + SizeArray_OutId;
	}
	//至少要空出一个容量
	if(EmptyNum<2){
		return -1;
	}

	Buffer_InId=fifo->Buffer_InId;
	Buffer_OutId=fifo->Buffer_OutId;
	BufferSize=fifo->BufferSize;
	if(Buffer_InId < Buffer_OutId){
		EmptySize = Buffer_OutId - Buffer_InId;
	}else{
		EmptySize = BufferSize - Buffer_InId;
		if(EmptySize < Buffer_OutId){
			EmptySize = Buffer_OutId;
		}
	}
	//容量是否足够
	if(EmptySize<Len){

		return -2;
	}

	//如果到此处 说明肯定可写入 要不从0写入要不从fifo->Buffer_InId写入

	//装填数据
	//判断从0写入还是从fifo->Buffer_InId写入
	if((BufferSize - Buffer_InId)<Len){
		//从0写入
		dst_ucp=fifo->Buffer;

		i=Len;
		while(i>7){
			i-=8;

			dst_ucp[0]=Data[0];
			dst_ucp[1]=Data[1];
			dst_ucp[2]=Data[2];
			dst_ucp[3]=Data[3];
			dst_ucp[4]=Data[4];
			dst_ucp[5]=Data[5];
			dst_ucp[6]=Data[6];
			dst_ucp[7]=Data[7];

			dst_ucp=&dst_ucp[8];
			Data=&Data[8];
		}
		while(i>0){
			i--;

			dst_ucp[0]=Data[0];

			dst_ucp=&dst_ucp[1];
			Data=&Data[1];
		}

		Buffer_InId=Len;
	}else{
		//从fifo->Buffer_InId写入
		dst_ucp=fifo->Buffer;
		dst_ucp=&dst_ucp[Buffer_InId];

		i=Len;
		while(i>7){
			i-=8;

			dst_ucp[0]=Data[0];
			dst_ucp[1]=Data[1];
			dst_ucp[2]=Data[2];
			dst_ucp[3]=Data[3];
			dst_ucp[4]=Data[4];
			dst_ucp[5]=Data[5];
			dst_ucp[6]=Data[6];
			dst_ucp[7]=Data[7];

			dst_ucp=&dst_ucp[8];
			Data=&Data[8];
		}
		while(i>0){
			i--;

			dst_ucp[0]=Data[0];

			dst_ucp=&dst_ucp[1];
			Data=&Data[1];
		}

		if((Buffer_InId+Len)==BufferSize){
			fifo->Buffer_InId=0;
		}else{
			fifo->Buffer_InId=Buffer_InId+Len;
		}
	}

	fifo->SizeArray[SizeArray_InId]=Len;

	if(SizeArray_InId==(SizeArraySize-1)){
		fifo->SizeArray_InId=0;
	}else{
		fifo->SizeArray_InId=SizeArray_InId+1;
	}

	return 0;
}

/**
 * @brief 向FIFO中添加包
 * @param fifo FIFO结构体
 * @param Data 要添加的数据
 * @param Len 长度
 * @return 0:成功 其他:失败 空间或剩余数量不足
 */
int H_FIFO_Pack_UInt32_AddPack(H_FIFO_Pack_UInt32_Def* fifo,Huint32_ptr Data,int Len){

	int EmptySize;
	int EmptyNum;
	int SizeArray_InId;
	int SizeArray_OutId;
	int Buffer_InId;
	int Buffer_OutId;
	int SizeArraySize;
	int BufferSize;
	volatile Huint32* dst_ucp;
	int i;


	SizeArray_InId=fifo->SizeArray_InId;
	SizeArray_OutId=fifo->SizeArray_OutId;
	SizeArraySize=fifo->SizeArraySize;
	//判断是否有足够容量
	if(SizeArray_InId < SizeArray_OutId){
		EmptyNum = SizeArray_OutId - SizeArray_InId;
	}else{
		EmptyNum = SizeArraySize - SizeArray_InId + SizeArray_OutId;
	}
	//至少要空出一个容量
	if(EmptyNum<2){
		return -1;
	}

	Buffer_InId=fifo->Buffer_InId;
	Buffer_OutId=fifo->Buffer_OutId;
	BufferSize=fifo->BufferSize;
	if(Buffer_InId < Buffer_OutId){
		EmptySize = Buffer_OutId - Buffer_InId;
	}else{
		EmptySize = BufferSize - Buffer_InId;
		if(EmptySize < Buffer_OutId){
			EmptySize = Buffer_OutId;
		}
	}
	//容量是否足够
	if(EmptySize<Len){

		return -2;
	}

	//如果到此处 说明肯定可写入 要不从0写入要不从fifo->Buffer_InId写入

	//装填数据
	//判断从0写入还是从fifo->Buffer_InId写入
	if((BufferSize - Buffer_InId)<Len){
		//从0写入
		dst_ucp=fifo->Buffer;

		i=Len;
		while(i>7){
			i-=8;

			dst_ucp[0]=Data[0];
			dst_ucp[1]=Data[1];
			dst_ucp[2]=Data[2];
			dst_ucp[3]=Data[3];
			dst_ucp[4]=Data[4];
			dst_ucp[5]=Data[5];
			dst_ucp[6]=Data[6];
			dst_ucp[7]=Data[7];

			dst_ucp=&dst_ucp[8];
			Data=&Data[8];
		}
		while(i>0){
			i--;

			dst_ucp[0]=Data[0];

			dst_ucp=&dst_ucp[1];
			Data=&Data[1];
		}

		Buffer_InId=Len;
	}else{
		//从fifo->Buffer_InId写入
		dst_ucp=fifo->Buffer;
		dst_ucp=&dst_ucp[Buffer_InId];

		i=Len;
		while(i>7){
			i-=8;

			dst_ucp[0]=Data[0];
			dst_ucp[1]=Data[1];
			dst_ucp[2]=Data[2];
			dst_ucp[3]=Data[3];
			dst_ucp[4]=Data[4];
			dst_ucp[5]=Data[5];
			dst_ucp[6]=Data[6];
			dst_ucp[7]=Data[7];

			dst_ucp=&dst_ucp[8];
			Data=&Data[8];
		}
		while(i>0){
			i--;

			dst_ucp[0]=Data[0];

			dst_ucp=&dst_ucp[1];
			Data=&Data[1];
		}

		if((Buffer_InId+Len)==BufferSize){
			fifo->Buffer_InId=0;
		}else{
			fifo->Buffer_InId=Buffer_InId+Len;
		}
	}

	fifo->SizeArray[SizeArray_InId]=Len;

	if(SizeArray_InId==(SizeArraySize-1)){
		fifo->SizeArray_InId=0;
	}else{
		fifo->SizeArray_InId=SizeArray_InId+1;
	}

	return 0;
}

/**
 * @brief 向FIFO中添加包
 * @param fifo FIFO结构体
 * @param Data 要添加的数据
 * @param Len 长度
 * @return 0:成功 其他:失败 空间或剩余数量不足
 */
int H_FIFO_Pack_UInt64_AddPack(H_FIFO_Pack_UInt64_Def* fifo,Huint64_ptr Data,int Len){

	int EmptySize;
	int EmptyNum;
	int SizeArray_InId;
	int SizeArray_OutId;
	int Buffer_InId;
	int Buffer_OutId;
	int SizeArraySize;
	int BufferSize;
	volatile Huint64* dst_ucp;
	int i;


	SizeArray_InId=fifo->SizeArray_InId;
	SizeArray_OutId=fifo->SizeArray_OutId;
	SizeArraySize=fifo->SizeArraySize;
	//判断是否有足够容量
	if(SizeArray_InId < SizeArray_OutId){
		EmptyNum = SizeArray_OutId - SizeArray_InId;
	}else{
		EmptyNum = SizeArraySize - SizeArray_InId + SizeArray_OutId;
	}
	//至少要空出一个容量
	if(EmptyNum<2){
		return -1;
	}

	Buffer_InId=fifo->Buffer_InId;
	Buffer_OutId=fifo->Buffer_OutId;
	BufferSize=fifo->BufferSize;
	if(Buffer_InId < Buffer_OutId){
		EmptySize = Buffer_OutId - Buffer_InId;
	}else{
		EmptySize = BufferSize - Buffer_InId;
		if(EmptySize < Buffer_OutId){
			EmptySize = Buffer_OutId;
		}
	}
	//容量是否足够
	if(EmptySize<Len){

		return -2;
	}

	//如果到此处 说明肯定可写入 要不从0写入要不从fifo->Buffer_InId写入

	//装填数据
	//判断从0写入还是从fifo->Buffer_InId写入
	if((BufferSize - Buffer_InId)<Len){
		//从0写入
		dst_ucp=fifo->Buffer;

		i=Len;
		while(i>7){
			i-=8;

			dst_ucp[0]=Data[0];
			dst_ucp[1]=Data[1];
			dst_ucp[2]=Data[2];
			dst_ucp[3]=Data[3];
			dst_ucp[4]=Data[4];
			dst_ucp[5]=Data[5];
			dst_ucp[6]=Data[6];
			dst_ucp[7]=Data[7];

			dst_ucp=&dst_ucp[8];
			Data=&Data[8];
		}
		while(i>0){
			i--;

			dst_ucp[0]=Data[0];

			dst_ucp=&dst_ucp[1];
			Data=&Data[1];
		}

		Buffer_InId=Len;
	}else{
		//从fifo->Buffer_InId写入
		dst_ucp=fifo->Buffer;
		dst_ucp=&dst_ucp[Buffer_InId];

		i=Len;
		while(i>7){
			i-=8;

			dst_ucp[0]=Data[0];
			dst_ucp[1]=Data[1];
			dst_ucp[2]=Data[2];
			dst_ucp[3]=Data[3];
			dst_ucp[4]=Data[4];
			dst_ucp[5]=Data[5];
			dst_ucp[6]=Data[6];
			dst_ucp[7]=Data[7];

			dst_ucp=&dst_ucp[8];
			Data=&Data[8];
		}
		while(i>0){
			i--;

			dst_ucp[0]=Data[0];

			dst_ucp=&dst_ucp[1];
			Data=&Data[1];
		}

		if((Buffer_InId+Len)==BufferSize){
			fifo->Buffer_InId=0;
		}else{
			fifo->Buffer_InId=Buffer_InId+Len;
		}
	}

	fifo->SizeArray[SizeArray_InId]=Len;

	if(SizeArray_InId==(SizeArraySize-1)){
		fifo->SizeArray_InId=0;
	}else{
		fifo->SizeArray_InId=SizeArray_InId+1;
	}

	return 0;
}






/**
 * @brief 向FIFO中添加包(首Data添加通道号)
 * @param fifo FIFO结构体
 * @param channel 通道号
 * @param Data 要添加的数据
 * @param Len 长度
 * @return 0:成功 其他:失败 空间或剩余数量不足
 */
int H_FIFO_Pack_Byte_AddPackChannel(H_FIFO_Pack_Byte_Def* fifo,Hbyte channel,Hbyte_ptr Data,int Len){
	int EmptySize;
	int EmptyNum;
	int SizeArray_InId;
	int SizeArray_OutId;
	int Buffer_InId;
	int Buffer_OutId;
	int SizeArraySize;
	int BufferSize;
	volatile Hbyte* dst_ucp;
	int i;


	SizeArray_InId=fifo->SizeArray_InId;
	SizeArray_OutId=fifo->SizeArray_OutId;
	SizeArraySize=fifo->SizeArraySize;
	//判断是否有足够容量
	if(SizeArray_InId < SizeArray_OutId){
		EmptyNum = SizeArray_OutId - SizeArray_InId;
	}else{
		EmptyNum = SizeArraySize - SizeArray_InId + SizeArray_OutId;
	}
	//至少要空出一个容量
	if(EmptyNum<2){
		return -1;
	}

	Buffer_InId=fifo->Buffer_InId;
	Buffer_OutId=fifo->Buffer_OutId;
	BufferSize=fifo->BufferSize;
	if(Buffer_InId < Buffer_OutId){
		EmptySize = Buffer_OutId - Buffer_InId;
	}else{
		EmptySize = BufferSize - Buffer_InId;
		if(EmptySize < Buffer_OutId){
			EmptySize = Buffer_OutId;
		}
	}
	//容量是否足够
	if(EmptySize<(Len+1)){

		return -2;
	}

	//如果到此处 说明肯定可写入 要不从0写入要不从stream->Buffer_InId写入

	//装填数据
	//判断从0写入还是从fifo->Buffer_InId写入
	if((BufferSize - Buffer_InId)<(Len+1)){
		//从0写入
		dst_ucp=fifo->Buffer;
		dst_ucp[0]=channel;
		dst_ucp=&dst_ucp[1];

		i=Len;
		while(i>7){
			i-=8;

			dst_ucp[0]=Data[0];
			dst_ucp[1]=Data[1];
			dst_ucp[2]=Data[2];
			dst_ucp[3]=Data[3];
			dst_ucp[4]=Data[4];
			dst_ucp[5]=Data[5];
			dst_ucp[6]=Data[6];
			dst_ucp[7]=Data[7];

			dst_ucp=&dst_ucp[8];
			Data=&Data[8];
		}
		while(i>0){
			i--;

			dst_ucp[0]=Data[0];

			dst_ucp=&dst_ucp[1];
			Data=&Data[1];
		}

		Buffer_InId=Len+1U;
	}else{
		//从fifo->Buffer_InId写入
		dst_ucp=fifo->Buffer;
		dst_ucp=&dst_ucp[Buffer_InId];
		dst_ucp[0]=channel;
		dst_ucp=&dst_ucp[1];

		i=Len;
		while(i>7){
			i-=8;

			dst_ucp[0]=Data[0];
			dst_ucp[1]=Data[1];
			dst_ucp[2]=Data[2];
			dst_ucp[3]=Data[3];
			dst_ucp[4]=Data[4];
			dst_ucp[5]=Data[5];
			dst_ucp[6]=Data[6];
			dst_ucp[7]=Data[7];

			dst_ucp=&dst_ucp[8];
			Data=&Data[8];
		}
		while(i>0){
			i--;

			dst_ucp[0]=Data[0];

			dst_ucp=&dst_ucp[1];
			Data=&Data[1];
		}

		if((Buffer_InId+Len+1U)==BufferSize){
			fifo->Buffer_InId=0;
		}else{
			fifo->Buffer_InId=Buffer_InId+Len+1U;
		}
	}

	fifo->SizeArray[SizeArray_InId]=Len+1U;

	if(SizeArray_InId==(SizeArraySize-1)){
		fifo->SizeArray_InId=0;
	}else{
		fifo->SizeArray_InId=SizeArray_InId+1;
	}

	return 0;
}

/**
 * @brief 向FIFO中添加包(首Data添加通道号)
 * @param fifo FIFO结构体
 * @param channel 通道号
 * @param Data 要添加的数据
 * @param Len 长度
 * @return 0:成功 其他:失败 空间或剩余数量不足
 */
int H_FIFO_Pack_UInt16_AddPackChannel(H_FIFO_Pack_UInt16_Def* fifo,Huint16 channel,Huint16_ptr Data,int Len){
	int EmptySize;
	int EmptyNum;
	int SizeArray_InId;
	int SizeArray_OutId;
	int Buffer_InId;
	int Buffer_OutId;
	int SizeArraySize;
	int BufferSize;
	volatile Huint16* dst_ucp;
	int i;


	SizeArray_InId=fifo->SizeArray_InId;
	SizeArray_OutId=fifo->SizeArray_OutId;
	SizeArraySize=fifo->SizeArraySize;
	//判断是否有足够容量
	if(SizeArray_InId < SizeArray_OutId){
		EmptyNum = SizeArray_OutId - SizeArray_InId;
	}else{
		EmptyNum = SizeArraySize - SizeArray_InId + SizeArray_OutId;
	}
	//至少要空出一个容量
	if(EmptyNum<2){
		return -1;
	}

	Buffer_InId=fifo->Buffer_InId;
	Buffer_OutId=fifo->Buffer_OutId;
	BufferSize=fifo->BufferSize;
	if(Buffer_InId < Buffer_OutId){
		EmptySize = Buffer_OutId - Buffer_InId;
	}else{
		EmptySize = BufferSize - Buffer_InId;
		if(EmptySize < Buffer_OutId){
			EmptySize = Buffer_OutId;
		}
	}
	//容量是否足够
	if(EmptySize<(Len+1)){

		return -2;
	}

	//如果到此处 说明肯定可写入 要不从0写入要不从stream->Buffer_InId写入

	//装填数据
	//判断从0写入还是从fifo->Buffer_InId写入
	if((BufferSize - Buffer_InId)<(Len+1)){
		//从0写入
		dst_ucp=fifo->Buffer;
		dst_ucp[0]=channel;
		dst_ucp=&dst_ucp[1];

		i=Len;
		while(i>7){
			i-=8;

			dst_ucp[0]=Data[0];
			dst_ucp[1]=Data[1];
			dst_ucp[2]=Data[2];
			dst_ucp[3]=Data[3];
			dst_ucp[4]=Data[4];
			dst_ucp[5]=Data[5];
			dst_ucp[6]=Data[6];
			dst_ucp[7]=Data[7];

			dst_ucp=&dst_ucp[8];
			Data=&Data[8];
		}
		while(i>0){
			i--;

			dst_ucp[0]=Data[0];

			dst_ucp=&dst_ucp[1];
			Data=&Data[1];
		}

		Buffer_InId=Len+1U;
	}else{
		//从fifo->Buffer_InId写入
		dst_ucp=fifo->Buffer;
		dst_ucp=&dst_ucp[Buffer_InId];
		dst_ucp[0]=channel;
		dst_ucp=&dst_ucp[1];

		i=Len;
		while(i>7){
			i-=8;

			dst_ucp[0]=Data[0];
			dst_ucp[1]=Data[1];
			dst_ucp[2]=Data[2];
			dst_ucp[3]=Data[3];
			dst_ucp[4]=Data[4];
			dst_ucp[5]=Data[5];
			dst_ucp[6]=Data[6];
			dst_ucp[7]=Data[7];

			dst_ucp=&dst_ucp[8];
			Data=&Data[8];
		}
		while(i>0){
			i--;

			dst_ucp[0]=Data[0];

			dst_ucp=&dst_ucp[1];
			Data=&Data[1];
		}

		if((Buffer_InId+Len+1U)==BufferSize){
			fifo->Buffer_InId=0;
		}else{
			fifo->Buffer_InId=Buffer_InId+Len+1U;
		}
	}

	fifo->SizeArray[SizeArray_InId]=Len+1U;

	if(SizeArray_InId==(SizeArraySize-1)){
		fifo->SizeArray_InId=0;
	}else{
		fifo->SizeArray_InId=SizeArray_InId+1;
	}

	return 0;
}

/**
 * @brief 向FIFO中添加包(首Data添加通道号)
 * @param fifo FIFO结构体
 * @param channel 通道号
 * @param Data 要添加的数据
 * @param Len 长度
 * @return 0:成功 其他:失败 空间或剩余数量不足
 */
int H_FIFO_Pack_UInt32_AddPackChannel(H_FIFO_Pack_UInt32_Def* fifo,Huint32 channel,Huint32_ptr Data,int Len){
	int EmptySize;
	int EmptyNum;
	int SizeArray_InId;
	int SizeArray_OutId;
	int Buffer_InId;
	int Buffer_OutId;
	int SizeArraySize;
	int BufferSize;
	volatile Huint32* dst_ucp;
	int i;


	SizeArray_InId=fifo->SizeArray_InId;
	SizeArray_OutId=fifo->SizeArray_OutId;
	SizeArraySize=fifo->SizeArraySize;
	//判断是否有足够容量
	if(SizeArray_InId < SizeArray_OutId){
		EmptyNum = SizeArray_OutId - SizeArray_InId;
	}else{
		EmptyNum = SizeArraySize - SizeArray_InId + SizeArray_OutId;
	}
	//至少要空出一个容量
	if(EmptyNum<2){
		return -1;
	}

	Buffer_InId=fifo->Buffer_InId;
	Buffer_OutId=fifo->Buffer_OutId;
	BufferSize=fifo->BufferSize;
	if(Buffer_InId < Buffer_OutId){
		EmptySize = Buffer_OutId - Buffer_InId;
	}else{
		EmptySize = BufferSize - Buffer_InId;
		if(EmptySize < Buffer_OutId){
			EmptySize = Buffer_OutId;
		}
	}
	//容量是否足够
	if(EmptySize<(Len+1)){

		return -2;
	}

	//如果到此处 说明肯定可写入 要不从0写入要不从stream->Buffer_InId写入

	//装填数据
	//判断从0写入还是从fifo->Buffer_InId写入
	if((BufferSize - Buffer_InId)<(Len+1)){
		//从0写入
		dst_ucp=fifo->Buffer;
		dst_ucp[0]=channel;
		dst_ucp=&dst_ucp[1];

		i=Len;
		while(i>7){
			i-=8;

			dst_ucp[0]=Data[0];
			dst_ucp[1]=Data[1];
			dst_ucp[2]=Data[2];
			dst_ucp[3]=Data[3];
			dst_ucp[4]=Data[4];
			dst_ucp[5]=Data[5];
			dst_ucp[6]=Data[6];
			dst_ucp[7]=Data[7];

			dst_ucp=&dst_ucp[8];
			Data=&Data[8];
		}
		while(i>0){
			i--;

			dst_ucp[0]=Data[0];

			dst_ucp=&dst_ucp[1];
			Data=&Data[1];
		}

		Buffer_InId=Len+1U;
	}else{
		//从fifo->Buffer_InId写入
		dst_ucp=fifo->Buffer;
		dst_ucp=&dst_ucp[Buffer_InId];
		dst_ucp[0]=channel;
		dst_ucp=&dst_ucp[1];

		i=Len;
		while(i>7){
			i-=8;

			dst_ucp[0]=Data[0];
			dst_ucp[1]=Data[1];
			dst_ucp[2]=Data[2];
			dst_ucp[3]=Data[3];
			dst_ucp[4]=Data[4];
			dst_ucp[5]=Data[5];
			dst_ucp[6]=Data[6];
			dst_ucp[7]=Data[7];

			dst_ucp=&dst_ucp[8];
			Data=&Data[8];
		}
		while(i>0){
			i--;

			dst_ucp[0]=Data[0];

			dst_ucp=&dst_ucp[1];
			Data=&Data[1];
		}

		if((Buffer_InId+Len+1U)==BufferSize){
			fifo->Buffer_InId=0;
		}else{
			fifo->Buffer_InId=Buffer_InId+Len+1U;
		}
	}

	fifo->SizeArray[SizeArray_InId]=Len+1U;

	if(SizeArray_InId==(SizeArraySize-1)){
		fifo->SizeArray_InId=0;
	}else{
		fifo->SizeArray_InId=SizeArray_InId+1;
	}

	return 0;
}

/**
 * @brief 向FIFO中添加包(首Data添加通道号)
 * @param fifo FIFO结构体
 * @param channel 通道号
 * @param Data 要添加的数据
 * @param Len 长度
 * @return 0:成功 其他:失败 空间或剩余数量不足
 */
int H_FIFO_Pack_UInt64_AddPackChannel(H_FIFO_Pack_UInt64_Def* fifo,Huint64 channel,Huint64_ptr Data,int Len){
	int EmptySize;
	int EmptyNum;
	int SizeArray_InId;
	int SizeArray_OutId;
	int Buffer_InId;
	int Buffer_OutId;
	int SizeArraySize;
	int BufferSize;
	volatile Huint64* dst_ucp;
	int i;


	SizeArray_InId=fifo->SizeArray_InId;
	SizeArray_OutId=fifo->SizeArray_OutId;
	SizeArraySize=fifo->SizeArraySize;
	//判断是否有足够容量
	if(SizeArray_InId < SizeArray_OutId){
		EmptyNum = SizeArray_OutId - SizeArray_InId;
	}else{
		EmptyNum = SizeArraySize - SizeArray_InId + SizeArray_OutId;
	}
	//至少要空出一个容量
	if(EmptyNum<2){
		return -1;
	}

	Buffer_InId=fifo->Buffer_InId;
	Buffer_OutId=fifo->Buffer_OutId;
	BufferSize=fifo->BufferSize;
	if(Buffer_InId < Buffer_OutId){
		EmptySize = Buffer_OutId - Buffer_InId;
	}else{
		EmptySize = BufferSize - Buffer_InId;
		if(EmptySize < Buffer_OutId){
			EmptySize = Buffer_OutId;
		}
	}
	//容量是否足够
	if(EmptySize<(Len+1)){

		return -2;
	}

	//如果到此处 说明肯定可写入 要不从0写入要不从stream->Buffer_InId写入

	//装填数据
	//判断从0写入还是从fifo->Buffer_InId写入
	if((BufferSize - Buffer_InId)<(Len+1)){
		//从0写入
		dst_ucp=fifo->Buffer;
		dst_ucp[0]=channel;
		dst_ucp=&dst_ucp[1];

		i=Len;
		while(i>7){
			i-=8;

			dst_ucp[0]=Data[0];
			dst_ucp[1]=Data[1];
			dst_ucp[2]=Data[2];
			dst_ucp[3]=Data[3];
			dst_ucp[4]=Data[4];
			dst_ucp[5]=Data[5];
			dst_ucp[6]=Data[6];
			dst_ucp[7]=Data[7];

			dst_ucp=&dst_ucp[8];
			Data=&Data[8];
		}
		while(i>0){
			i--;

			dst_ucp[0]=Data[0];

			dst_ucp=&dst_ucp[1];
			Data=&Data[1];
		}

		Buffer_InId=Len+1U;
	}else{
		//从fifo->Buffer_InId写入
		dst_ucp=fifo->Buffer;
		dst_ucp=&dst_ucp[Buffer_InId];
		dst_ucp[0]=channel;
		dst_ucp=&dst_ucp[1];

		i=Len;
		while(i>7){
			i-=8;

			dst_ucp[0]=Data[0];
			dst_ucp[1]=Data[1];
			dst_ucp[2]=Data[2];
			dst_ucp[3]=Data[3];
			dst_ucp[4]=Data[4];
			dst_ucp[5]=Data[5];
			dst_ucp[6]=Data[6];
			dst_ucp[7]=Data[7];

			dst_ucp=&dst_ucp[8];
			Data=&Data[8];
		}
		while(i>0){
			i--;

			dst_ucp[0]=Data[0];

			dst_ucp=&dst_ucp[1];
			Data=&Data[1];
		}

		if((Buffer_InId+Len+1U)==BufferSize){
			fifo->Buffer_InId=0;
		}else{
			fifo->Buffer_InId=Buffer_InId+Len+1U;
		}
	}

	fifo->SizeArray[SizeArray_InId]=Len+1U;

	if(SizeArray_InId==(SizeArraySize-1)){
		fifo->SizeArray_InId=0;
	}else{
		fifo->SizeArray_InId=SizeArray_InId+1;
	}

	return 0;
}






/**
 * @brief 读取数据包
 * @param fifo FIFO结构体
 * @param LenPtr 整型指针 用于返回读取的长度(单位:Data的类型的一个元素的大小)
 * @return 数据指针 如果为NULL((void*)0)表示无可用数据
 */
Hbyte_ptr H_FIFO_Pack_Byte_Read(H_FIFO_Pack_Byte_Def* fifo,int* LenPtr){
	int PackSize;
	int Buffer_OutId;

	if(H_FIFO_Pack_isNoEmpty(fifo))
	{
		PackSize=fifo->SizeArray[fifo->SizeArray_OutId];
		Buffer_OutId=fifo->Buffer_OutId;
		if((Buffer_OutId + PackSize) > fifo->BufferSize){
			fifo->Buffer_OutId=0;
		}

		*LenPtr=PackSize;
		return (Hbyte_ptr)&fifo->Buffer[Buffer_OutId];
	}
	else{
		*LenPtr=0;
		return NULL;
	}
}

/**
 * @brief 读取数据包
 * @param fifo FIFO结构体
 * @param LenPtr 整型指针 用于返回读取的长度(单位:Data的类型的一个元素的大小)
 * @return 数据指针 如果为NULL((void*)0)表示无可用数据
 */
Huint16_ptr H_FIFO_Pack_UInt16_Read(H_FIFO_Pack_UInt16_Def* fifo,int* LenPtr){
	int PackSize;
	int Buffer_OutId;

	if(H_FIFO_Pack_isNoEmpty(fifo))
	{
		PackSize=fifo->SizeArray[fifo->SizeArray_OutId];
		Buffer_OutId=fifo->Buffer_OutId;
		if((Buffer_OutId + PackSize) > fifo->BufferSize){
			fifo->Buffer_OutId=0;
		}

		*LenPtr=PackSize;
		return (Huint16_ptr)&fifo->Buffer[Buffer_OutId];
	}
	else{
		*LenPtr=0;
		return NULL;
	}
}

/**
 * @brief 读取数据包
 * @param fifo FIFO结构体
 * @param LenPtr 整型指针 用于返回读取的长度(单位:Data的类型的一个元素的大小)
 * @return 数据指针 如果为NULL((void*)0)表示无可用数据
 */
Huint32_ptr H_FIFO_Pack_UInt32_Read(H_FIFO_Pack_UInt32_Def* fifo,int* LenPtr){
	int PackSize;
	int Buffer_OutId;

	if(H_FIFO_Pack_isNoEmpty(fifo))
	{
		PackSize=fifo->SizeArray[fifo->SizeArray_OutId];
		Buffer_OutId=fifo->Buffer_OutId;
		if((Buffer_OutId + PackSize) > fifo->BufferSize){
			fifo->Buffer_OutId=0;
		}

		*LenPtr=PackSize;
		return (Huint32_ptr)&fifo->Buffer[Buffer_OutId];
	}
	else{
		*LenPtr=0;
		return NULL;
	}
}

/**
 * @brief 读取数据包
 * @param fifo FIFO结构体
 * @param LenPtr 整型指针 用于返回读取的长度(单位:Data的类型的一个元素的大小)
 * @return 数据指针 如果为NULL((void*)0)表示无可用数据
 */
Huint64_ptr H_FIFO_Pack_UInt64_Read(H_FIFO_Pack_UInt64_Def* fifo,int* LenPtr){
	int PackSize;
	int Buffer_OutId;

	if(H_FIFO_Pack_isNoEmpty(fifo))
	{
		PackSize=fifo->SizeArray[fifo->SizeArray_OutId];
		Buffer_OutId=fifo->Buffer_OutId;
		if((Buffer_OutId + PackSize) > fifo->BufferSize){
			fifo->Buffer_OutId=0;
		}

		*LenPtr=PackSize;
		return (Huint64_ptr)&fifo->Buffer[Buffer_OutId];
	}
	else{
		*LenPtr=0;
		return NULL;
	}
}






/**
 * @brief 读取数据指针切换到下一个(如果有的话)
 * @param fifo FIFO结构体
 * @return 无
 */
void H_FIFO_Pack_Byte_Next(H_FIFO_Pack_Byte_Def* fifo){
	int PackSize;
	int Buffer_OutId;
	int SizeArray_OutId;

	SizeArray_OutId=fifo->SizeArray_OutId;
	PackSize=fifo->SizeArray[SizeArray_OutId];
	Buffer_OutId=fifo->Buffer_OutId;
	if((Buffer_OutId + PackSize) > fifo->BufferSize){
		fifo->Buffer_OutId=PackSize;
	}else{
		fifo->Buffer_OutId=Buffer_OutId+PackSize;
	}
	
	if(SizeArray_OutId==(fifo->SizeArraySize-1)){
		fifo->SizeArray_OutId=0;
	}else{
		fifo->SizeArray_OutId=SizeArray_OutId+1;
	}
}

/**
 * @brief 读取数据指针切换到下一个(如果有的话)
 * @param fifo FIFO结构体
 * @return 无
 */
void H_FIFO_Pack_UInt16_Next(H_FIFO_Pack_UInt16_Def* fifo){
	int PackSize;
	int Buffer_OutId;
	int SizeArray_OutId;

	SizeArray_OutId=fifo->SizeArray_OutId;
	PackSize=fifo->SizeArray[SizeArray_OutId];
	Buffer_OutId=fifo->Buffer_OutId;
	if((Buffer_OutId + PackSize) > fifo->BufferSize){
		fifo->Buffer_OutId=PackSize;
	}else{
		fifo->Buffer_OutId=Buffer_OutId+PackSize;
	}
	
	if(SizeArray_OutId==(fifo->SizeArraySize-1)){
		fifo->SizeArray_OutId=0;
	}else{
		fifo->SizeArray_OutId=SizeArray_OutId+1;
	}
}

/**
 * @brief 读取数据指针切换到下一个(如果有的话)
 * @param fifo FIFO结构体
 * @return 无
 */
void H_FIFO_Pack_UInt32_Next(H_FIFO_Pack_UInt32_Def* fifo){
	int PackSize;
	int Buffer_OutId;
	int SizeArray_OutId;

	SizeArray_OutId=fifo->SizeArray_OutId;
	PackSize=fifo->SizeArray[SizeArray_OutId];
	Buffer_OutId=fifo->Buffer_OutId;
	if((Buffer_OutId + PackSize) > fifo->BufferSize){
		fifo->Buffer_OutId=PackSize;
	}else{
		fifo->Buffer_OutId=Buffer_OutId+PackSize;
	}
	
	if(SizeArray_OutId==(fifo->SizeArraySize-1)){
		fifo->SizeArray_OutId=0;
	}else{
		fifo->SizeArray_OutId=SizeArray_OutId+1;
	}
}

/**
 * @brief 读取数据指针切换到下一个(如果有的话)
 * @param fifo FIFO结构体
 * @return 无
 */
void H_FIFO_Pack_UInt64_Next(H_FIFO_Pack_UInt64_Def* fifo){
	int PackSize;
	int Buffer_OutId;
	int SizeArray_OutId;

	SizeArray_OutId=fifo->SizeArray_OutId;
	PackSize=fifo->SizeArray[SizeArray_OutId];
	Buffer_OutId=fifo->Buffer_OutId;
	if((Buffer_OutId + PackSize) > fifo->BufferSize){
		fifo->Buffer_OutId=PackSize;
	}else{
		fifo->Buffer_OutId=Buffer_OutId+PackSize;
	}
	
	if(SizeArray_OutId==(fifo->SizeArraySize-1)){
		fifo->SizeArray_OutId=0;
	}else{
		fifo->SizeArray_OutId=SizeArray_OutId+1;
	}
}






/**
 * @brief 获取可再写入的最大长度
 * @param fifo FIFO结构体
 * @return 可填入的最大长度
 */
int H_FIFO_Pack_Byte_GetEmptySize(H_FIFO_Pack_Byte_Def* fifo){
	int EmptySize;
	int EmptyNum;
	int SizeArray_InId;
	int SizeArray_OutId;
	int Buffer_InId;
	int Buffer_OutId;
	int SizeArraySize;
	int BufferSize;

	SizeArray_InId=fifo->SizeArray_InId;
	SizeArray_OutId=fifo->SizeArray_OutId;
	SizeArraySize=fifo->SizeArraySize;
	//计算容量
	if(SizeArray_InId < SizeArray_OutId){
		EmptyNum = SizeArray_OutId - SizeArray_InId;
	}else{
		EmptyNum = SizeArraySize - SizeArray_InId + SizeArray_OutId;
	}
	//至少要空出一个容量
	if(EmptyNum<2){
		return 0;
	}

	Buffer_InId=fifo->Buffer_InId;
	Buffer_OutId=fifo->Buffer_OutId;
	BufferSize=fifo->BufferSize;
	//计算空间
	if(Buffer_InId < Buffer_OutId){
		EmptySize = Buffer_OutId - Buffer_InId;
	}else{
		EmptySize = BufferSize - Buffer_InId;
		if(EmptySize < Buffer_OutId){
			EmptySize = Buffer_OutId;
		}
	}
	return EmptySize;
}

/**
 * @brief 获取可再写入的最大长度
 * @param fifo FIFO结构体
 * @return 可填入的最大长度
 */
int H_FIFO_Pack_UInt16_GetEmptySize(H_FIFO_Pack_UInt16_Def* fifo){
	int EmptySize;
	int EmptyNum;
	int SizeArray_InId;
	int SizeArray_OutId;
	int Buffer_InId;
	int Buffer_OutId;
	int SizeArraySize;
	int BufferSize;

	SizeArray_InId=fifo->SizeArray_InId;
	SizeArray_OutId=fifo->SizeArray_OutId;
	SizeArraySize=fifo->SizeArraySize;
	//计算容量
	if(SizeArray_InId < SizeArray_OutId){
		EmptyNum = SizeArray_OutId - SizeArray_InId;
	}else{
		EmptyNum = SizeArraySize - SizeArray_InId + SizeArray_OutId;
	}
	//至少要空出一个容量
	if(EmptyNum<2){
		return 0;
	}

	Buffer_InId=fifo->Buffer_InId;
	Buffer_OutId=fifo->Buffer_OutId;
	BufferSize=fifo->BufferSize;
	//计算空间
	if(Buffer_InId < Buffer_OutId){
		EmptySize = Buffer_OutId - Buffer_InId;
	}else{
		EmptySize = BufferSize - Buffer_InId;
		if(EmptySize < Buffer_OutId){
			EmptySize = Buffer_OutId;
		}
	}
	return EmptySize;
}

/**
 * @brief 获取可再写入的最大长度
 * @param fifo FIFO结构体
 * @return 可填入的最大长度
 */
int H_FIFO_Pack_UInt32_GetEmptySize(H_FIFO_Pack_UInt32_Def* fifo){
	int EmptySize;
	int EmptyNum;
	int SizeArray_InId;
	int SizeArray_OutId;
	int Buffer_InId;
	int Buffer_OutId;
	int SizeArraySize;
	int BufferSize;

	SizeArray_InId=fifo->SizeArray_InId;
	SizeArray_OutId=fifo->SizeArray_OutId;
	SizeArraySize=fifo->SizeArraySize;
	//计算容量
	if(SizeArray_InId < SizeArray_OutId){
		EmptyNum = SizeArray_OutId - SizeArray_InId;
	}else{
		EmptyNum = SizeArraySize - SizeArray_InId + SizeArray_OutId;
	}
	//至少要空出一个容量
	if(EmptyNum<2){
		return 0;
	}

	Buffer_InId=fifo->Buffer_InId;
	Buffer_OutId=fifo->Buffer_OutId;
	BufferSize=fifo->BufferSize;
	//计算空间
	if(Buffer_InId < Buffer_OutId){
		EmptySize = Buffer_OutId - Buffer_InId;
	}else{
		EmptySize = BufferSize - Buffer_InId;
		if(EmptySize < Buffer_OutId){
			EmptySize = Buffer_OutId;
		}
	}
	return EmptySize;
}

/**
 * @brief 获取可再写入的最大长度
 * @param fifo FIFO结构体
 * @return 可填入的最大长度
 */
int H_FIFO_Pack_UInt64_GetEmptySize(H_FIFO_Pack_UInt64_Def* fifo){
	int EmptySize;
	int EmptyNum;
	int SizeArray_InId;
	int SizeArray_OutId;
	int Buffer_InId;
	int Buffer_OutId;
	int SizeArraySize;
	int BufferSize;

	SizeArray_InId=fifo->SizeArray_InId;
	SizeArray_OutId=fifo->SizeArray_OutId;
	SizeArraySize=fifo->SizeArraySize;
	//计算容量
	if(SizeArray_InId < SizeArray_OutId){
		EmptyNum = SizeArray_OutId - SizeArray_InId;
	}else{
		EmptyNum = SizeArraySize - SizeArray_InId + SizeArray_OutId;
	}
	//至少要空出一个容量
	if(EmptyNum<2){
		return 0;
	}

	Buffer_InId=fifo->Buffer_InId;
	Buffer_OutId=fifo->Buffer_OutId;
	BufferSize=fifo->BufferSize;
	//计算空间
	if(Buffer_InId < Buffer_OutId){
		EmptySize = Buffer_OutId - Buffer_InId;
	}else{
		EmptySize = BufferSize - Buffer_InId;
		if(EmptySize < Buffer_OutId){
			EmptySize = Buffer_OutId;
		}
	}
	return EmptySize;
}






/**
 * @brief 初始化数据流
 * @param fifo FIFO结构体
 * @param Buffer FIFO使用的缓存
 * @param BufferSize 缓存大小(单位:Buffer的类型的一个元素的大小)
 * @param SizeArray 长度表
 * @param SizeArraySize 长度表大小(单位:sizeof(int))
 * @return 无
 */
void H_FIFO_Pack_Byte_Init(H_FIFO_Pack_Byte_Def* fifo,Hbyte_ptr Buffer,int BufferSize,int* SizeArray,int SizeArraySize){

	fifo->Buffer_InId=0;
	fifo->Buffer_OutId=0;
	fifo->SizeArray_InId=0;
	fifo->SizeArray_InId=0;

	fifo->Buffer=Buffer;
	fifo->BufferSize=BufferSize;
	fifo->SizeArray=SizeArray;
	fifo->SizeArraySize=SizeArraySize;
}

/**
 * @brief 初始化数据流
 * @param fifo FIFO结构体
 * @param Buffer FIFO使用的缓存
 * @param BufferSize 缓存大小(单位:Buffer的类型的一个元素的大小)
 * @param SizeArray 长度表
 * @param SizeArraySize 长度表大小(单位:sizeof(int))
 * @return 无
 */
void H_FIFO_Pack_UInt16_Init(H_FIFO_Pack_UInt16_Def* fifo,Huint16_ptr Buffer,int BufferSize,int* SizeArray,int SizeArraySize){

	fifo->Buffer_InId=0;
	fifo->Buffer_OutId=0;
	fifo->SizeArray_InId=0;
	fifo->SizeArray_InId=0;

	fifo->Buffer=Buffer;
	fifo->BufferSize=BufferSize;
	fifo->SizeArray=SizeArray;
	fifo->SizeArraySize=SizeArraySize;
}

/**
 * @brief 初始化数据流
 * @param fifo FIFO结构体
 * @param Buffer FIFO使用的缓存
 * @param BufferSize 缓存大小(单位:Buffer的类型的一个元素的大小)
 * @param SizeArray 长度表
 * @param SizeArraySize 长度表大小(单位:sizeof(int))
 * @return 无
 */
void H_FIFO_Pack_UInt32_Init(H_FIFO_Pack_UInt32_Def* fifo,Huint32_ptr Buffer,int BufferSize,int* SizeArray,int SizeArraySize){

	fifo->Buffer_InId=0;
	fifo->Buffer_OutId=0;
	fifo->SizeArray_InId=0;
	fifo->SizeArray_InId=0;

	fifo->Buffer=Buffer;
	fifo->BufferSize=BufferSize;
	fifo->SizeArray=SizeArray;
	fifo->SizeArraySize=SizeArraySize;
}

/**
 * @brief 初始化数据流
 * @param fifo FIFO结构体
 * @param Buffer FIFO使用的缓存
 * @param BufferSize 缓存大小(单位:Buffer的类型的一个元素的大小)
 * @param SizeArray 长度表
 * @param SizeArraySize 长度表大小(单位:sizeof(int))
 * @return 无
 */
void H_FIFO_Pack_UInt64_Init(H_FIFO_Pack_UInt64_Def* fifo,Huint64_ptr Buffer,int BufferSize,int* SizeArray,int SizeArraySize){

	fifo->Buffer_InId=0;
	fifo->Buffer_OutId=0;
	fifo->SizeArray_InId=0;
	fifo->SizeArray_InId=0;

	fifo->Buffer=Buffer;
	fifo->BufferSize=BufferSize;
	fifo->SizeArray=SizeArray;
	fifo->SizeArraySize=SizeArraySize;
}




